// exports.AL_Framework_Node_Pool_Manager = exports.NodePool = void 0;
// var i = (function () {
//     function e(e) {
//         this.name = "";
//         this.prefab = null;
//         this.pool = null;
//         this.name = e.name;
//         this.prefab = e.prefab;
//         this.pool = new cc.NodePool();
//     }
//     e.prototype.create = function (e) {
//         var t;
//         var o = e.count || 0;
//         var i = e.prefab || this.prefab;
//         this.prefab = i;
//         for (var n = 0; n < o; n++) {
//             t = cc.instantiate(i);
//             this.pool.put(t);
//         }
//     };
//     e.prototype.size = function () {
//         return this.pool.size();
//     };
//     e.prototype.get = function () {
//         return this.size() > 0 ? this.pool.get() : cc.instantiate(this.prefab);
//     };
//     e.prototype.put = function (e) {
//         this.pool.put(e);
//     };
//     e.prototype.clear = function () {
//         this.pool.clear();
//     };
//     return e;
// })();
// exports.NodePool = i;
// var n = (function () {
//     function e() {
//         this.pools = new Map();
//     }
//     e.Instance = function () {
//         return this._instance || (this._instance = new e());
//     };
//     e.prototype.chuangjian_pool = function (e) {
//         if (!this.pools.has(e.name)) {
//             this.pools.set(e.name, new i(e));
//         }
//         return this.pools.get(e.name);
//     };
//     e.prototype.shanchu_pool = function (e) {
//         "string" == typeof e
//             ? this.pools.has(e) && (this.pools.get(e).clear(), this.pools.delete(e))
//             : e && e instanceof i && this.shanchu_pool(e.name);
//     };
//     e.prototype.huoqu_pool = function (e, t, o) {
//         if (void 0 === t) {
//             t = !0;
//         }
//         return this.pools.has(e)
//             ? this.pools.get(e)
//             : t
//             ? this.chuangjian_pool({
//                   name: e,
//                   prefab: o
//               })
//             : null;
//     };
//     e._instance = null;
//     return e;
// })();
// exports.AL_Framework_Node_Pool_Manager = n;


/**
 * NodePool类，用于管理节点对象池
 */
class NodePool {
    constructor(config) {
        this.name = config.name || "";
        this.prefab = config.prefab || null;
        this.pool = new cc.NodePool();
    }

    /**
     * 创建对象池
     * @param {Object} config - 配置对象
     * @param {number} config.count - 要创建的初始对象数量
     * @param {cc.Prefab} config.prefab - 对象池使用的预制体
     */
    create(config) {
        const count = config.count || 0;
        const prefab = config.prefab || this.prefab;
        this.prefab = prefab;
        for (let i = 0; i < count; i++) {
            const newNode = cc.instantiate(prefab);
            this.pool.put(newNode);
        }
    }

    /**
     * 获取对象池的大小
     * @returns {number} 对象池的大小
     */
    size() {
        return this.pool.size();
    }

    /**
     * 从对象池中获取对象
     * @returns {cc.Node} 获取到的对象
     */
    get() {
        return this.size() > 0 ? this.pool.get() : cc.instantiate(this.prefab);
    }

    /**
     * 将对象放回对象池
     * @param {cc.Node} node - 要放回对象池的对象
     */
    put(node) {
        this.pool.put(node);
    }

    /**
     * 清空对象池
     */
    clear() {
        this.pool.clear();
    }
}

/**
 * NodePoolManager类，用于管理多个对象池
 */
class AL_Framework_Node_Pool_Manager {
    constructor() {
        this.pools = new Map();
    }

    /**
     * 获取NodePoolManager的单例实例
     * @returns {AL_Framework_Node_Pool_Manager} NodePoolManager的单例实例
     */
    static Instance() {
        if (!this._instance) {
            this._instance = new AL_Framework_Node_Pool_Manager();
        }
        return this._instance;
    }

    /**
     * 创建一个新的对象池
     * @param {Object} config - 配置对象
     * @returns {NodePool} 创建的对象池
     */
    chuangjian_pool(config) {
        if (!this.pools.has(config.name)) {
            this.pools.set(config.name, new NodePool(config));
        }
        return this.pools.get(config.name);
    }

    /**
     * 删除指定的对象池
     * @param {string|NodePool} pool - 要删除的对象池的名称或对象池实例
     */
    shanchu_pool(pool) {
        if (typeof pool === "string") {
            if (this.pools.has(pool)) {
                this.pools.get(pool).clear();
                this.pools.delete(pool);
            }
        } else if (pool && pool instanceof NodePool) {
            this.shanchu_pool(pool.name);
        }
    }

    /**
     * 获取指定的对象池
     * @param {string} name - 对象池的名称
     * @param {boolean} [autoCreate=true] - 是否自动创建对象池
     * @param {cc.Prefab} [prefab] - 预制体
     * @returns {NodePool|null} 获取到的对象池
     */
    huoqu_pool(name, autoCreate = true, prefab) {
        if (this.pools.has(name)) {
            return this.pools.get(name);
        } else if (autoCreate) {
            return this.chuangjian_pool({
                name: name,
                prefab: prefab
            });
        } else {
            return null;
        }
    }
}

// 导出模块
exports.NodePool = NodePool;
exports.AL_Framework_Node_Pool_Manager = AL_Framework_Node_Pool_Manager;
